package com.knowledgegraph.util;

import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.crypto.SecretKey;
import java.util.Date;

/**
 * JWT工具类
 * 
 * @author system
 * @since 2024-01-01
 */
@Slf4j
@Component
public class JwtUtil {

    @Value("${jwt.secret}")
    private String secret;

    @Value("${jwt.expiration}")
    private Long expiration;

    @Value("${jwt.header}")
    private String header;

    @Value("${jwt.prefix}")
    private String prefix;

    /**
     * 生成JWT令牌
     * 
     * @param userId 用户ID
     * @return JWT令牌
     */
    public String generateToken(Long userId) {
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + expiration);

        // 使用更安全的密钥生成方式
        SecretKey key = getSecretKey();

        return Jwts.builder()
                .setSubject(String.valueOf(userId))
                .setIssuedAt(now)
                .setExpiration(expiryDate)
                .signWith(key, SignatureAlgorithm.HS512)
                .compact();
    }
    
    /**
     * 获取安全的密钥
     */
    private SecretKey getSecretKey() {
        // 确保密钥长度足够（至少64字节用于HS512）
        String paddedSecret = secret;
        while (paddedSecret.getBytes().length < 64) {
            paddedSecret += secret;
        }
        return Keys.hmacShaKeyFor(paddedSecret.getBytes());
    }

    /**
     * 从JWT令牌中获取用户ID
     * 
     * @param token JWT令牌
     * @return 用户ID
     */
    public Long getUserIdFromToken(String token) {
        try {
            SecretKey key = getSecretKey();
            Claims claims = Jwts.parserBuilder()
                    .setSigningKey(key)
                    .build()
                    .parseClaimsJws(token)
                    .getBody();
            return Long.valueOf(claims.getSubject());
        } catch (Exception e) {
            log.error("从JWT令牌中获取用户ID失败", e);
            return null;
        }
    }

    /**
     * 验证JWT令牌
     * 
     * @param token JWT令牌
     * @return 是否有效
     */
    public boolean validateToken(String token) {
        try {
            SecretKey key = getSecretKey();
            Jwts.parserBuilder()
                    .setSigningKey(key)
                    .build()
                    .parseClaimsJws(token);
            return true;
        } catch (SecurityException ex) {
            log.error("JWT签名无效", ex);
        } catch (MalformedJwtException ex) {
            log.error("JWT令牌格式错误", ex);
        } catch (ExpiredJwtException ex) {
            log.error("JWT令牌已过期", ex);
        } catch (UnsupportedJwtException ex) {
            log.error("不支持的JWT令牌", ex);
        } catch (IllegalArgumentException ex) {
            log.error("JWT令牌为空", ex);
        }
        return false;
    }

    /**
     * 从请求头中获取JWT令牌
     * 
     * @param authHeader 授权头
     * @return JWT令牌
     */
    public String getTokenFromHeader(String authHeader) {
        if (authHeader != null && authHeader.startsWith(prefix + " ")) {
            return authHeader.substring(prefix.length() + 1);
        }
        return null;
    }

    public String getHeader() {
        return header;
    }

    public String getPrefix() {
        return prefix;
    }
}